package com.smartboot.plus.holder;

import com.smartboot.plus.ignite.cache.CacheValue;
import com.smartboot.plus.ignite.cache.MqttAclCache;
import com.smartboot.plus.ignite.cache.MqttNodeCache;
import tech.smartboot.mqtt.client.MqttClient;
import tech.smartboot.mqtt.plugin.spec.BrokerContext;
import tech.smartboot.mqtt.plugin.spec.MqttSession;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Broker 上下文持有器（全局单例）
 * 用于持有 MQTT Broker 的上下文及权限缓存
 */
public class BrokerContextHolder {

    /**
     * Broker 上下文对象，插件与主框架交互的桥梁
     */
    private static BrokerContext context;

    /**
     * 记录带有时间信息的 ACL 缓存（用于判断缓存是否过期）
     * Key: username 或 clientId
     */
    private static ConcurrentHashMap<String, CacheValue<MqttAclCache>> mqttAclCacheTimeMap = new ConcurrentHashMap<>();

    /**
     * 纯 ACL 缓存数据（不含时间戳信息）
     * Key: username 或 clientId
     */
    private static ConcurrentHashMap<String, MqttAclCache> mqttAclCacheMap = new ConcurrentHashMap<>();

    /**
     * 已连接节点
     */
    private static Map<String, MqttClient> connectedNodeMap = new ConcurrentHashMap<>();



    private static Map<String, MqttNodeCache> mqttNodeCacheMap = new ConcurrentHashMap<>();

    private static Map<MqttSession, String> coreSessionMap = new ConcurrentHashMap<>();

    /**
     * 设置 Broker 上下文
     *
     * @param ctx 上下文对象
     */
    public static void set(BrokerContext ctx) {
        context = ctx;
    }

    /**
     * 获取 Broker 上下文
     *
     * @return BrokerContext
     */
    public static BrokerContext get() {
        return context;
    }

    /**
     * 设置 ACL 缓存（不含时间）
     *
     * @param ctx ACL 缓存 Map
     */
//    public static void setMqttAclCacheMap(ConcurrentHashMap<String, MqttAclCache> ctx) {
//        mqttAclCacheMap = Objects.requireNonNull(ctx, "mqttAclCacheMap 不能为 null");
//    }

    /**
     * 获取 ACL 缓存（不含时间）
     *
     * @return ACL Map
     */
    public static ConcurrentHashMap<String, MqttAclCache> getMqttAclCacheMap() {
        return mqttAclCacheMap;
    }

    /**
     * 设置 ACL 缓存（带时间戳）
     *
     * @param ctx 带时间的 ACL 缓存 Map
     */
//    public static void setMqttAclCacheTimeMap(ConcurrentHashMap<String, CacheValue<MqttAclCache>> ctx) {
//        mqttAclCacheTimeMap = Objects.requireNonNull(ctx, "mqttAclCacheTimeMap 不能为 null");
//    }

    /**
     * 获取 ACL 缓存（带时间戳）
     *
     * @return 带时间的 ACL Map
     */
    public static ConcurrentHashMap<String, CacheValue<MqttAclCache>> getMqttAclCacheTimeMap() {
        return mqttAclCacheTimeMap;
    }

    public static Map<String, MqttClient> getConnectedNodeMap() {
        return connectedNodeMap;
    }

//    public static void setConnectedNodeMap(Map<String, MqttClient> ctx) {
//        connectedNodeMap = Objects.requireNonNull(ctx, "connectedNodeMap 不能为 null");
//    }



    public static Map<String, MqttNodeCache> getMqttNodeCacheMap() {
        return mqttNodeCacheMap;
    }

//    public static void setMqttNodeCacheMap(Map<String, MqttNodeCache> ctx) {
//        mqttNodeCacheMap = Objects.requireNonNull(ctx, "connectedNodeMap 不能为 null");
//    }


    public static Map<MqttSession, String> getCoreSessionMap() {
        return coreSessionMap;
    }

//    public static void setCoreSessionMap( Map<MqttSession, String>  ctx) {
//        coreSessionMap = Objects.requireNonNull(ctx, "coreSessionMap 不能为 null");
//    }
}
